V3 Core Implementation

What This Skill Does

Implements the core TypeScript modules for claude-flow v3 following Domain-Driven Design principles, clean architecture patterns, and modern TypeScript best practices with comprehensive test coverage.

Quick Start

bash
1# Initialize core implementation
2Task("Core foundation", "Set up DDD domain structure and base classes", "core-implementer")
3
4# Domain implementation (parallel)
5Task("Task domain", "Implement task management domain with entities and services", "core-implementer")
6Task("Session domain", "Implement session management domain", "core-implementer")
7Task("Health domain", "Implement health monitoring domain", "core-implementer")

Core Implementation Architecture

Domain Structure

src/
├── core/
│   ├── kernel/                     # Microkernel pattern
│   │   ├── claude-flow-kernel.ts
│   │   ├── domain-registry.ts
│   │   └── plugin-loader.ts
│   │
│   ├── domains/                    # DDD Bounded Contexts
│   │   ├── task-management/
│   │   │   ├── entities/
│   │   │   ├── value-objects/
│   │   │   ├── services/
│   │   │   ├── repositories/
│   │   │   └── events/
│   │   │
│   │   ├── session-management/
│   │   ├── health-monitoring/
│   │   ├── lifecycle-management/
│   │   └── event-coordination/
│   │
│   ├── shared/                     # Shared kernel
│   │   ├── domain/
│   │   │   ├── entity.ts
│   │   │   ├── value-object.ts
│   │   │   ├── domain-event.ts
│   │   │   └── aggregate-root.ts
│   │   │
│   │   ├── infrastructure/
│   │   │   ├── event-bus.ts
│   │   │   ├── dependency-container.ts
│   │   │   └── logger.ts
│   │   │
│   │   └── types/
│   │       ├── common.ts
│   │       ├── errors.ts
│   │       └── interfaces.ts
│   │
│   └── application/                # Application services
│       ├── use-cases/
│       ├── commands/
│       ├── queries/
│       └── handlers/

Base Domain Classes

Entity Base Class

typescript
1// src/core/shared/domain/entity.ts
2export abstract class Entity<T> {
3  protected readonly _id: T;
4  private _domainEvents: DomainEvent[] = [];
5
6  constructor(id: T) {
7    this._id = id;
8  }
9
10  get id(): T {
11    return this._id;
12  }
13
14  public equals(object?: Entity<T>): boolean {
15    if (object == null || object == undefined) {
16      return false;
17    }
18
19    if (this === object) {
20      return true;
21    }
22
23    if (!(object instanceof Entity)) {
24      return false;
25    }
26
27    return this._id === object._id;
28  }
29
30  protected addDomainEvent(domainEvent: DomainEvent): void {
31    this._domainEvents.push(domainEvent);
32  }
33
34  public getUncommittedEvents(): DomainEvent[] {
35    return this._domainEvents;
36  }
37
38  public markEventsAsCommitted(): void {
39    this._domainEvents = [];
40  }
41}

Value Object Base Class

typescript
1// src/core/shared/domain/value-object.ts
2export abstract class ValueObject<T> {
3  protected readonly props: T;
4
5  constructor(props: T) {
6    this.props = Object.freeze(props);
7  }
8
9  public equals(object?: ValueObject<T>): boolean {
10    if (object == null || object == undefined) {
11      return false;
12    }
13
14    if (this === object) {
15      return true;
16    }
17
18    return JSON.stringify(this.props) === JSON.stringify(object.props);
19  }
20
21  get value(): T {
22    return this.props;
23  }
24}

Aggregate Root

typescript
1// src/core/shared/domain/aggregate-root.ts
2export abstract class AggregateRoot<T> extends Entity<T> {
3  private _version: number = 0;
4
5  get version(): number {
6    return this._version;
7  }
8
9  protected incrementVersion(): void {
10    this._version++;
11  }
12
13  public applyEvent(event: DomainEvent): void {
14    this.addDomainEvent(event);
15    this.incrementVersion();
16  }
17}

Task Management Domain Implementation

Task Entity

typescript
1// src/core/domains/task-management/entities/task.entity.ts
2import { AggregateRoot } from "../../../shared/domain/aggregate-root";
3import { TaskId } from "../value-objects/task-id.vo";
4import { TaskStatus } from "../value-objects/task-status.vo";
5import { Priority } from "../value-objects/priority.vo";
6import { TaskAssignedEvent } from "../events/task-assigned.event";
7
8interface TaskProps {
9  id: TaskId;
10  description: string;
11  priority: Priority;
12  status: TaskStatus;
13  assignedAgentId?: string;
14  createdAt: Date;
15  updatedAt: Date;
16}
17
18export class Task extends AggregateRoot<TaskId> {
19  private props: TaskProps;
20
21  private constructor(props: TaskProps) {
22    super(props.id);
23    this.props = props;
24  }
25
26  static create(description: string, priority: Priority): Task {
27    const task = new Task({
28      id: TaskId.create(),
29      description,
30      priority,
31      status: TaskStatus.pending(),
32      createdAt: new Date(),
33      updatedAt: new Date(),
34    });
35
36    return task;
37  }
38
39  static reconstitute(props: TaskProps): Task {
40    return new Task(props);
41  }
42
43  public assignTo(agentId: string): void {
44    if (this.props.status.equals(TaskStatus.completed())) {
45      throw new Error("Cannot assign completed task");
46    }
47
48    this.props.assignedAgentId = agentId;
49    this.props.status = TaskStatus.assigned();
50    this.props.updatedAt = new Date();
51
52    this.applyEvent(
53      new TaskAssignedEvent(this.id.value, agentId, this.props.priority),
54    );
55  }
56
57  public complete(result: TaskResult): void {
58    if (!this.props.assignedAgentId) {
59      throw new Error("Cannot complete unassigned task");
60    }
61
62    this.props.status = TaskStatus.completed();
63    this.props.updatedAt = new Date();
64
65    this.applyEvent(
66      new TaskCompletedEvent(this.id.value, result, this.calculateDuration()),
67    );
68  }
69
70  // Getters
71  get description(): string {
72    return this.props.description;
73  }
74  get priority(): Priority {
75    return this.props.priority;
76  }
77  get status(): TaskStatus {
78    return this.props.status;
79  }
80  get assignedAgentId(): string | undefined {
81    return this.props.assignedAgentId;
82  }
83  get createdAt(): Date {
84    return this.props.createdAt;
85  }
86  get updatedAt(): Date {
87    return this.props.updatedAt;
88  }
89
90  private calculateDuration(): number {
91    return this.props.updatedAt.getTime() - this.props.createdAt.getTime();
92  }
93}

Task Value Objects

typescript
1// src/core/domains/task-management/value-objects/task-id.vo.ts
2export class TaskId extends ValueObject<string> {
3  private constructor(value: string) {
4    super({ value });
5  }
6
7  static create(): TaskId {
8    return new TaskId(crypto.randomUUID());
9  }
10
11  static fromString(id: string): TaskId {
12    if (!id || id.length === 0) {
13      throw new Error("TaskId cannot be empty");
14    }
15    return new TaskId(id);
16  }
17
18  get value(): string {
19    return this.props.value;
20  }
21}
22
23// src/core/domains/task-management/value-objects/task-status.vo.ts
24type TaskStatusType =
25  | "pending"
26  | "assigned"
27  | "in_progress"
28  | "completed"
29  | "failed";
30
31export class TaskStatus extends ValueObject<TaskStatusType> {
32  private constructor(status: TaskStatusType) {
33    super({ value: status });
34  }
35
36  static pending(): TaskStatus {
37    return new TaskStatus("pending");
38  }
39  static assigned(): TaskStatus {
40    return new TaskStatus("assigned");
41  }
42  static inProgress(): TaskStatus {
43    return new TaskStatus("in_progress");
44  }
45  static completed(): TaskStatus {
46    return new TaskStatus("completed");
47  }
48  static failed(): TaskStatus {
49    return new TaskStatus("failed");
50  }
51
52  get value(): TaskStatusType {
53    return this.props.value;
54  }
55
56  public isPending(): boolean {
57    return this.value === "pending";
58  }
59  public isAssigned(): boolean {
60    return this.value === "assigned";
61  }
62  public isInProgress(): boolean {
63    return this.value === "in_progress";
64  }
65  public isCompleted(): boolean {
66    return this.value === "completed";
67  }
68  public isFailed(): boolean {
69    return this.value === "failed";
70  }
71}
72
73// src/core/domains/task-management/value-objects/priority.vo.ts
74type PriorityLevel = "low" | "medium" | "high" | "critical";
75
76export class Priority extends ValueObject<PriorityLevel> {
77  private constructor(level: PriorityLevel) {
78    super({ value: level });
79  }
80
81  static low(): Priority {
82    return new Priority("low");
83  }
84  static medium(): Priority {
85    return new Priority("medium");
86  }
87  static high(): Priority {
88    return new Priority("high");
89  }
90  static critical(): Priority {
91    return new Priority("critical");
92  }
93
94  get value(): PriorityLevel {
95    return this.props.value;
96  }
97
98  public getNumericValue(): number {
99    const priorities = { low: 1, medium: 2, high: 3, critical: 4 };
100    return priorities[this.value];
101  }
102}

Domain Services

Task Scheduling Service

typescript
1// src/core/domains/task-management/services/task-scheduling.service.ts
2import { Injectable } from "../../../shared/infrastructure/dependency-container";
3import { Task } from "../entities/task.entity";
4import { Priority } from "../value-objects/priority.vo";
5
6@Injectable()
7export class TaskSchedulingService {
8  public prioritizeTasks(tasks: Task[]): Task[] {
9    return tasks.sort(
10      (a, b) => b.priority.getNumericValue() - a.priority.getNumericValue(),
11    );
12  }
13
14  public canSchedule(task: Task, agentCapacity: number): boolean {
15    if (agentCapacity <= 0) return false;
16
17    // Critical tasks always schedulable
18    if (task.priority.equals(Priority.critical())) return true;
19
20    // Other logic based on capacity
21    return true;
22  }
23
24  public calculateEstimatedDuration(task: Task): number {
25    // Simple heuristic - would use ML in real implementation
26    const baseTime = 300000; // 5 minutes
27    const priorityMultiplier = {
28      low: 0.5,
29      medium: 1.0,
30      high: 1.5,
31      critical: 2.0,
32    };
33
34    return baseTime * priorityMultiplier[task.priority.value];
35  }
36}

Repository Interfaces & Implementations

Task Repository Interface

typescript
1// src/core/domains/task-management/repositories/task.repository.ts
2export interface ITaskRepository {
3  save(task: Task): Promise<void>;
4  findById(id: TaskId): Promise<Task | null>;
5  findByAgentId(agentId: string): Promise<Task[]>;
6  findByStatus(status: TaskStatus): Promise<Task[]>;
7  findPendingTasks(): Promise<Task[]>;
8  delete(id: TaskId): Promise<void>;
9}

SQLite Implementation

typescript
1// src/core/domains/task-management/repositories/sqlite-task.repository.ts
2@Injectable()
3export class SqliteTaskRepository implements ITaskRepository {
4  constructor(
5    @Inject("Database") private db: Database,
6    @Inject("Logger") private logger: ILogger,
7  ) {}
8
9  async save(task: Task): Promise<void> {
10    const sql = `
11      INSERT OR REPLACE INTO tasks (
12        id, description, priority, status, assigned_agent_id, created_at, updated_at
13      ) VALUES (?, ?, ?, ?, ?, ?, ?)
14    `;
15
16    await this.db.run(sql, [
17      task.id.value,
18      task.description,
19      task.priority.value,
20      task.status.value,
21      task.assignedAgentId,
22      task.createdAt.toISOString(),
23      task.updatedAt.toISOString(),
24    ]);
25
26    this.logger.debug(`Task saved: ${task.id.value}`);
27  }
28
29  async findById(id: TaskId): Promise<Task | null> {
30    const sql = "SELECT * FROM tasks WHERE id = ?";
31    const row = await this.db.get(sql, [id.value]);
32
33    return row ? this.mapRowToTask(row) : null;
34  }
35
36  async findPendingTasks(): Promise<Task[]> {
37    const sql =
38      "SELECT * FROM tasks WHERE status = ? ORDER BY priority DESC, created_at ASC";
39    const rows = await this.db.all(sql, ["pending"]);
40
41    return rows.map((row) => this.mapRowToTask(row));
42  }
43
44  private mapRowToTask(row: any): Task {
45    return Task.reconstitute({
46      id: TaskId.fromString(row.id),
47      description: row.description,
48      priority: Priority.fromString(row.priority),
49      status: TaskStatus.fromString(row.status),
50      assignedAgentId: row.assigned_agent_id,
51      createdAt: new Date(row.created_at),
52      updatedAt: new Date(row.updated_at),
53    });
54  }
55}

Application Layer

Use Case Implementation

typescript
1// src/core/application/use-cases/assign-task.use-case.ts
2@Injectable()
3export class AssignTaskUseCase {
4  constructor(
5    @Inject("TaskRepository") private taskRepository: ITaskRepository,
6    @Inject("AgentRepository") private agentRepository: IAgentRepository,
7    @Inject("DomainEventBus") private eventBus: DomainEventBus,
8    @Inject("Logger") private logger: ILogger,
9  ) {}
10
11  async execute(command: AssignTaskCommand): Promise<AssignTaskResult> {
12    try {
13      // 1. Validate command
14      await this.validateCommand(command);
15
16      // 2. Load aggregates
17      const task = await this.taskRepository.findById(command.taskId);
18      if (!task) {
19        throw new TaskNotFoundError(command.taskId);
20      }
21
22      const agent = await this.agentRepository.findById(command.agentId);
23      if (!agent) {
24        throw new AgentNotFoundError(command.agentId);
25      }
26
27      // 3. Business logic
28      if (!agent.canAcceptTask(task)) {
29        throw new AgentCannotAcceptTaskError(command.agentId, command.taskId);
30      }
31
32      task.assignTo(command.agentId);
33      agent.acceptTask(task.id);
34
35      // 4. Persist changes
36      await Promise.all([
37        this.taskRepository.save(task),
38        this.agentRepository.save(agent),
39      ]);
40
41      // 5. Publish domain events
42      const events = [
43        ...task.getUncommittedEvents(),
44        ...agent.getUncommittedEvents(),
45      ];
46
47      for (const event of events) {
48        await this.eventBus.publish(event);
49      }
50
51      task.markEventsAsCommitted();
52      agent.markEventsAsCommitted();
53
54      // 6. Return result
55      this.logger.info(
56        `Task ${command.taskId.value} assigned to agent ${command.agentId}`,
57      );
58
59      return AssignTaskResult.success({
60        taskId: task.id,
61        agentId: command.agentId,
62        assignedAt: new Date(),
63      });
64    } catch (error) {
65      this.logger.error(
66        `Failed to assign task ${command.taskId.value}:`,
67        error,
68      );
69      return AssignTaskResult.failure(error);
70    }
71  }
72
73  private async validateCommand(command: AssignTaskCommand): Promise<void> {
74    if (!command.taskId) {
75      throw new ValidationError("Task ID is required");
76    }
77    if (!command.agentId) {
78      throw new ValidationError("Agent ID is required");
79    }
80  }
81}

Dependency Injection Setup

Container Configuration

typescript
1// src/core/shared/infrastructure/dependency-container.ts
2import { Container } from "inversify";
3import { TYPES } from "./types";
4
5export class DependencyContainer {
6  private container: Container;
7
8  constructor() {
9    this.container = new Container();
10    this.setupBindings();
11  }
12
13  private setupBindings(): void {
14    // Repositories
15    this.container
16      .bind<ITaskRepository>(TYPES.TaskRepository)
17      .to(SqliteTaskRepository)
18      .inSingletonScope();
19
20    this.container
21      .bind<IAgentRepository>(TYPES.AgentRepository)
22      .to(SqliteAgentRepository)
23      .inSingletonScope();
24
25    // Services
26    this.container
27      .bind<TaskSchedulingService>(TYPES.TaskSchedulingService)
28      .to(TaskSchedulingService)
29      .inSingletonScope();
30
31    // Use Cases
32    this.container
33      .bind<AssignTaskUseCase>(TYPES.AssignTaskUseCase)
34      .to(AssignTaskUseCase)
35      .inSingletonScope();
36
37    // Infrastructure
38    this.container
39      .bind<ILogger>(TYPES.Logger)
40      .to(ConsoleLogger)
41      .inSingletonScope();
42
43    this.container
44      .bind<DomainEventBus>(TYPES.DomainEventBus)
45      .to(InMemoryDomainEventBus)
46      .inSingletonScope();
47  }
48
49  get<T>(serviceIdentifier: symbol): T {
50    return this.container.get<T>(serviceIdentifier);
51  }
52
53  bind<T>(serviceIdentifier: symbol): BindingToSyntax<T> {
54    return this.container.bind<T>(serviceIdentifier);
55  }
56}

Modern TypeScript Configuration

Strict TypeScript Setup

json
1// tsconfig.json
2{
3  "compilerOptions": {
4    "target": "ES2022",
5    "lib": ["ES2022"],
6    "module": "NodeNext",
7    "moduleResolution": "NodeNext",
8    "declaration": true,
9    "outDir": "./dist",
10    "strict": true,
11    "exactOptionalPropertyTypes": true,
12    "noImplicitReturns": true,
13    "noFallthroughCasesInSwitch": true,
14    "noUncheckedIndexedAccess": true,
15    "noImplicitOverride": true,
16    "experimentalDecorators": true,
17    "emitDecoratorMetadata": true,
18    "skipLibCheck": true,
19    "forceConsistentCasingInFileNames": true,
20    "resolveJsonModule": true,
21    "esModuleInterop": true,
22    "allowSyntheticDefaultImports": true,
23    "baseUrl": ".",
24    "paths": {
25      "@/*": ["src/*"],
26      "@core/*": ["src/core/*"],
27      "@shared/*": ["src/core/shared/*"],
28      "@domains/*": ["src/core/domains/*"]
29    }
30  },
31  "include": ["src/**/*"],
32  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
33}

Testing Implementation

Domain Unit Tests

typescript
1// src/core/domains/task-management/__tests__/entities/task.entity.test.ts
2describe("Task Entity", () => {
3  let task: Task;
4
5  beforeEach(() => {
6    task = Task.create("Test task", Priority.medium());
7  });
8
9  describe("creation", () => {
10    it("should create task with pending status", () => {
11      expect(task.status.isPending()).toBe(true);
12      expect(task.description).toBe("Test task");
13      expect(task.priority.equals(Priority.medium())).toBe(true);
14    });
15
16    it("should generate unique ID", () => {
17      const task1 = Task.create("Task 1", Priority.low());
18      const task2 = Task.create("Task 2", Priority.low());
19
20      expect(task1.id.equals(task2.id)).toBe(false);
21    });
22  });
23
24  describe("assignment", () => {
25    it("should assign to agent and change status", () => {
26      const agentId = "agent-123";
27
28      task.assignTo(agentId);
29
30      expect(task.assignedAgentId).toBe(agentId);
31      expect(task.status.isAssigned()).toBe(true);
32    });
33
34    it("should emit TaskAssignedEvent when assigned", () => {
35      const agentId = "agent-123";
36
37      task.assignTo(agentId);
38
39      const events = task.getUncommittedEvents();
40      expect(events).toHaveLength(1);
41      expect(events[0]).toBeInstanceOf(TaskAssignedEvent);
42    });
43
44    it("should not allow assignment of completed task", () => {
45      task.assignTo("agent-123");
46      task.complete(TaskResult.success("done"));
47
48      expect(() => task.assignTo("agent-456")).toThrow(
49        "Cannot assign completed task",
50      );
51    });
52  });
53});

Integration Tests

typescript
1// src/core/domains/task-management/__tests__/integration/task-repository.integration.test.ts
2describe("TaskRepository Integration", () => {
3  let repository: SqliteTaskRepository;
4  let db: Database;
5
6  beforeEach(async () => {
7    db = new Database(":memory:");
8    await setupTasksTable(db);
9    repository = new SqliteTaskRepository(db, new ConsoleLogger());
10  });
11
12  afterEach(async () => {
13    await db.close();
14  });
15
16  it("should save and retrieve task", async () => {
17    const task = Task.create("Test task", Priority.high());
18
19    await repository.save(task);
20    const retrieved = await repository.findById(task.id);
21
22    expect(retrieved).toBeDefined();
23    expect(retrieved!.id.equals(task.id)).toBe(true);
24    expect(retrieved!.description).toBe("Test task");
25    expect(retrieved!.priority.equals(Priority.high())).toBe(true);
26  });
27
28  it("should find pending tasks ordered by priority", async () => {
29    const lowTask = Task.create("Low priority", Priority.low());
30    const highTask = Task.create("High priority", Priority.high());
31
32    await repository.save(lowTask);
33    await repository.save(highTask);
34
35    const pending = await repository.findPendingTasks();
36
37    expect(pending).toHaveLength(2);
38    expect(pending[0].id.equals(highTask.id)).toBe(true); // High priority first
39    expect(pending[1].id.equals(lowTask.id)).toBe(true);
40  });
41});

Performance Optimizations

Entity Caching

typescript
1// src/core/shared/infrastructure/entity-cache.ts
2@Injectable()
3export class EntityCache<T extends Entity<any>> {
4  private cache = new Map<string, { entity: T; timestamp: number }>();
5  private readonly ttl: number = 300000; // 5 minutes
6
7  set(id: string, entity: T): void {
8    this.cache.set(id, { entity, timestamp: Date.now() });
9  }
10
11  get(id: string): T | null {
12    const cached = this.cache.get(id);
13    if (!cached) return null;
14
15    // Check TTL
16    if (Date.now() - cached.timestamp > this.ttl) {
17      this.cache.delete(id);
18      return null;
19    }
20
21    return cached.entity;
22  }
23
24  invalidate(id: string): void {
25    this.cache.delete(id);
26  }
27
28  clear(): void {
29    this.cache.clear();
30  }
31}

Success Metrics

• Domain Isolation: 100% clean dependency boundaries
• Test Coverage: >90% unit test coverage for domain logic
• Type Safety: Strict TypeScript compilation with zero any types
• Performance: <50ms average use case execution time
• Memory Efficiency: <100MB heap usage for core domains
• Plugin Architecture: Modular domain loading capability

Related V3 Skills

• v3-ddd-architecture - DDD architectural design
• v3-mcp-optimization - MCP server integration
• v3-memory-unification - AgentDB repository integration
• v3-swarm-coordination - Swarm domain implementation

Usage Examples

Complete Core Implementation

bash
1# Full core module implementation
2Task("Core implementation",
3     "Implement all core domains with DDD patterns and comprehensive testing",
4     "core-implementer")

Domain-Specific Implementation

bash
1# Single domain implementation
2Task("Task domain implementation",
3     "Implement task management domain with entities, services, and repositories",
4     "core-implementer")